package nav

/*
#include<stdint.h>
#include<stdbool.h>
extern unsigned int nav_duDebugDraw_areaToCol(void * c_this,unsigned int area);
extern void nav_duDebugDraw_begin(void * c_this,unsigned int prim,float size);
extern void nav_duDebugDraw_Delete(void * c_this);
extern void nav_duDebugDraw_depthMask(void * c_this,bool state);
extern void nav_duDebugDraw_end(void * c_this);
extern void nav_duDebugDraw_texture(void * c_this,bool state);
extern void nav_duDebugDraw_vertex(void * c_this,void * pos,unsigned int color);
extern void nav_duDebugDraw_vertex11(void * c_this,float x,float y,float z,unsigned int color);
extern void nav_duDebugDraw_vertex12(void * c_this,void * pos,unsigned int color,void * uv);
extern void nav_duDebugDraw_vertex13(void * c_this,float x,float y,float z,unsigned int color,float u,float v);
extern void nav_duDisplayList_begin(void * c_this,unsigned int prim,float size);
extern void nav_duDisplayList_clear(void * c_this);
extern void nav_duDisplayList_Delete(void * c_this);
extern void nav_duDisplayList_depthMask(void * c_this,bool state);
extern void nav_duDisplayList_draw(void * c_this,void * dd);
extern void nav_duDisplayList_end(void * c_this);
extern void nav_duDisplayList_vertex(void * c_this,float x,float y,float z,unsigned int color);
extern void nav_duDisplayList_vertex11(void * c_this,void * pos,unsigned int color);
extern void nav_duAppendArc(void * dd,float x0,float y0,float z0,float x1,float y1,float z1,float h,float as0,float as1,unsigned int col);
extern void nav_duAppendArrow(void * dd,float x0,float y0,float z0,float x1,float y1,float z1,float as0,float as1,unsigned int col);
extern void nav_duAppendBox(void * dd,float minx,float miny,float minz,float maxx,float maxy,float maxz,void * fcol);
extern void nav_duAppendBoxPoints(void * dd,float minx,float miny,float minz,float maxx,float maxy,float maxz,unsigned int col);
extern void nav_duAppendBoxWire(void * dd,float minx,float miny,float minz,float maxx,float maxy,float maxz,unsigned int col);
extern void nav_duAppendCircle(void * dd,float x,float y,float z,float r,unsigned int col);
extern void nav_duAppendCross(void * dd,float x,float y,float z,float size,unsigned int col);
extern void nav_duAppendCylinder(void * dd,float minx,float miny,float minz,float maxx,float maxy,float maxz,unsigned int col);
extern void nav_duAppendCylinderWire(void * dd,float minx,float miny,float minz,float maxx,float maxy,float maxz,unsigned int col);
extern void nav_duCalcBoxColors(void * colors,unsigned int colTop,unsigned int colSide);
extern unsigned int nav_duDarkenCol(unsigned int col);
extern void nav_duDebugDrawArc(void * dd,float x0,float y0,float z0,float x1,float y1,float z1,float h,float as0,float as1,unsigned int col,float lineWidth);
extern void nav_duDebugDrawArrow(void * dd,float x0,float y0,float z0,float x1,float y1,float z1,float as0,float as1,unsigned int col,float lineWidth);
extern void nav_duDebugDrawBox(void * dd,float minx,float miny,float minz,float maxx,float maxy,float maxz,void * fcol);
extern void nav_duDebugDrawBoxWire(void * dd,float minx,float miny,float minz,float maxx,float maxy,float maxz,unsigned int col,float lineWidth);
extern void nav_duDebugDrawCircle(void * dd,float x,float y,float z,float r,unsigned int col,float lineWidth);
extern void nav_duDebugDrawCross(void * dd,float x,float y,float z,float size,unsigned int col,float lineWidth);
extern void nav_duDebugDrawCylinder(void * dd,float minx,float miny,float minz,float maxx,float maxy,float maxz,unsigned int col);
extern void nav_duDebugDrawCylinderWire(void * dd,float minx,float miny,float minz,float maxx,float maxy,float maxz,unsigned int col,float lineWidth);
extern void nav_duDebugDrawGridXZ(void * dd,float ox,float oy,float oz,int w,int h,float size,unsigned int col,float lineWidth);
extern unsigned int nav_duIntToCol(int i,int a);
extern void nav_duIntToCol11(int i,void * col);
extern unsigned int nav_duLerpCol(unsigned int ca,unsigned int cb,unsigned int u);
extern unsigned int nav_duMultCol(unsigned int col,unsigned int d);
extern unsigned int nav_duRGBA(int r,int g,int b,int a);
extern unsigned int nav_duRGBAf(float fr,float fg,float fb,float fa);
extern unsigned int nav_duTransCol(unsigned int c,unsigned int a);

*/
import "C"
import "unsafe"
import "gitee.com/hasika/cgo"

var _ unsafe.Pointer
var _ cgo.NotUsed

/*
Abstract debug draw interface.
*/
type DuDebugDrawPtr uintptr

/*
Compute a color for given area.

public virtual unsigned int areaToCol(unsigned int area)
*/
func (p DuDebugDrawPtr) AreaToCol(area uint32) uint32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_area C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_area = (C.uint)(area)
	wrap_out := C.nav_duDebugDraw_areaToCol(wrap_this, wrap_arg_area)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Begin drawing primitives.

@param prim [in] primitive type to draw, one of rcDebugDrawPrimitives.
@param size [in] size of a primitive, applies to point size and line width only.

public virtual void begin(duDebugDrawPrimitives prim, float size=1) = 0
*/
func (p DuDebugDrawPtr) Begin(prim EnumDuDebugDrawPrimitives, size float32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_prim C.uint
	var wrap_arg_size C.float
	wrap_this = unsafe.Pointer(p)
	wrap_arg_prim = (C.uint)(prim)
	wrap_arg_size = (C.float)(size)
	C.nav_duDebugDraw_begin(wrap_this, wrap_arg_prim, wrap_arg_size)
}

/*
public virtual void Delete() = 0
*/
func (p DuDebugDrawPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_duDebugDraw_Delete(wrap_this)
}

/*
public virtual void depthMask(bool state) = 0
*/
func (p DuDebugDrawPtr) DepthMask(state bool) {
	var wrap_this unsafe.Pointer
	var wrap_arg_state C._Bool
	wrap_this = unsafe.Pointer(p)
	wrap_arg_state = (C._Bool)(state)
	C.nav_duDebugDraw_depthMask(wrap_this, wrap_arg_state)
}

/*
End drawing primitives.

public virtual void end() = 0
*/
func (p DuDebugDrawPtr) End() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_duDebugDraw_end(wrap_this)
}

/*
public virtual void texture(bool state) = 0
*/
func (p DuDebugDrawPtr) Texture(state bool) {
	var wrap_this unsafe.Pointer
	var wrap_arg_state C._Bool
	wrap_this = unsafe.Pointer(p)
	wrap_arg_state = (C._Bool)(state)
	C.nav_duDebugDraw_texture(wrap_this, wrap_arg_state)
}

/*
Submit a vertex

@param pos [in] position of the verts.
@param color [in] color of the verts.

public virtual void vertex(float const * pos, unsigned int color) = 0
*/
func (p DuDebugDrawPtr) Vertex(pos *float32, color uint32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_pos unsafe.Pointer
	var wrap_arg_color C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_pos = (unsafe.Pointer)(pos)
	wrap_arg_color = (C.uint)(color)
	C.nav_duDebugDraw_vertex(wrap_this, wrap_arg_pos, wrap_arg_color)
}

/*
Submit a vertex

@param x,y,z [in] position of the verts.
@param color [in] color of the verts.

public virtual void vertex(float const x, float const y, float const z, unsigned int color) = 0
*/
func (p DuDebugDrawPtr) Vertex11(x float32, y float32, z float32, color uint32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_x C.float
	var wrap_arg_y C.float
	var wrap_arg_z C.float
	var wrap_arg_color C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_x = (C.float)(x)
	wrap_arg_y = (C.float)(y)
	wrap_arg_z = (C.float)(z)
	wrap_arg_color = (C.uint)(color)
	C.nav_duDebugDraw_vertex11(wrap_this, wrap_arg_x, wrap_arg_y, wrap_arg_z, wrap_arg_color)
}

/*
Submit a vertex

@param pos [in] position of the verts.
@param color [in] color of the verts.
@param uv [in] the uv coordinates of the verts.

public virtual void vertex(float const * pos, unsigned int color, float const * uv) = 0
*/
func (p DuDebugDrawPtr) Vertex12(pos *float32, color uint32, uv *float32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_pos unsafe.Pointer
	var wrap_arg_color C.uint
	var wrap_arg_uv unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_pos = (unsafe.Pointer)(pos)
	wrap_arg_color = (C.uint)(color)
	wrap_arg_uv = (unsafe.Pointer)(uv)
	C.nav_duDebugDraw_vertex12(wrap_this, wrap_arg_pos, wrap_arg_color, wrap_arg_uv)
}

/*
Submit a vertex

@param x,y,z [in] position of the verts.
@param color [in] color of the verts.
@param u,v [in] the uv coordinates of the verts.

public virtual void vertex(float const x, float const y, float const z, unsigned int color, float const u, float const v) = 0
*/
func (p DuDebugDrawPtr) Vertex13(x float32, y float32, z float32, color uint32, u float32, v float32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_x C.float
	var wrap_arg_y C.float
	var wrap_arg_z C.float
	var wrap_arg_color C.uint
	var wrap_arg_u C.float
	var wrap_arg_v C.float
	wrap_this = unsafe.Pointer(p)
	wrap_arg_x = (C.float)(x)
	wrap_arg_y = (C.float)(y)
	wrap_arg_z = (C.float)(z)
	wrap_arg_color = (C.uint)(color)
	wrap_arg_u = (C.float)(u)
	wrap_arg_v = (C.float)(v)
	C.nav_duDebugDraw_vertex13(wrap_this, wrap_arg_x, wrap_arg_y, wrap_arg_z, wrap_arg_color, wrap_arg_u, wrap_arg_v)
}

/*
Abstract debug draw interface.
*/
type DuDisplayListPtr uintptr

func (p DuDisplayListPtr) AsDuDebugDrawPtr() DuDebugDrawPtr {
	return DuDebugDrawPtr(p)
}

/*
Begin drawing primitives.

@param prim [in] primitive type to draw, one of rcDebugDrawPrimitives.
@param size [in] size of a primitive, applies to point size and line width only.

public virtual void begin(duDebugDrawPrimitives prim, float size=1)
*/
func (p DuDisplayListPtr) Begin(prim EnumDuDebugDrawPrimitives, size float32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_prim C.uint
	var wrap_arg_size C.float
	wrap_this = unsafe.Pointer(p)
	wrap_arg_prim = (C.uint)(prim)
	wrap_arg_size = (C.float)(size)
	C.nav_duDisplayList_begin(wrap_this, wrap_arg_prim, wrap_arg_size)
}

/*
public void clear()
*/
func (p DuDisplayListPtr) Clear() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_duDisplayList_clear(wrap_this)
}

/*
public virtual void Delete()
*/
func (p DuDisplayListPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_duDisplayList_Delete(wrap_this)
}

/*
public virtual void depthMask(bool state)
*/
func (p DuDisplayListPtr) DepthMask(state bool) {
	var wrap_this unsafe.Pointer
	var wrap_arg_state C._Bool
	wrap_this = unsafe.Pointer(p)
	wrap_arg_state = (C._Bool)(state)
	C.nav_duDisplayList_depthMask(wrap_this, wrap_arg_state)
}

/*
public void draw(duDebugDraw * dd)
*/
func (p DuDisplayListPtr) Draw(dd DuDebugDrawPtr) {
	var wrap_this unsafe.Pointer
	var wrap_arg_dd unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_dd = (unsafe.Pointer)(dd)
	C.nav_duDisplayList_draw(wrap_this, wrap_arg_dd)
}

/*
End drawing primitives.

public virtual void end()
*/
func (p DuDisplayListPtr) End() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_duDisplayList_end(wrap_this)
}

/*
Submit a vertex

@param x,y,z [in] position of the verts.
@param color [in] color of the verts.

public virtual void vertex(float const x, float const y, float const z, unsigned int color)
*/
func (p DuDisplayListPtr) Vertex(x float32, y float32, z float32, color uint32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_x C.float
	var wrap_arg_y C.float
	var wrap_arg_z C.float
	var wrap_arg_color C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_x = (C.float)(x)
	wrap_arg_y = (C.float)(y)
	wrap_arg_z = (C.float)(z)
	wrap_arg_color = (C.uint)(color)
	C.nav_duDisplayList_vertex(wrap_this, wrap_arg_x, wrap_arg_y, wrap_arg_z, wrap_arg_color)
}

/*
Submit a vertex

@param pos [in] position of the verts.
@param color [in] color of the verts.

public virtual void vertex(float const * pos, unsigned int color)
*/
func (p DuDisplayListPtr) Vertex11(pos *float32, color uint32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_pos unsafe.Pointer
	var wrap_arg_color C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_pos = (unsafe.Pointer)(pos)
	wrap_arg_color = (C.uint)(color)
	C.nav_duDisplayList_vertex11(wrap_this, wrap_arg_pos, wrap_arg_color)
}

/*
void duAppendArc(duDebugDraw * dd, float const x0, float const y0, float const z0, float const x1, float const y1, float const z1, float const h, float const as0, float const as1, unsigned int col)
*/
func DuAppendArc(dd DuDebugDrawPtr, x0 float32, y0 float32, z0 float32, x1 float32, y1 float32, z1 float32, h float32, as0 float32, as1 float32, col uint32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_x0 C.float
	var wrap_arg_y0 C.float
	var wrap_arg_z0 C.float
	var wrap_arg_x1 C.float
	var wrap_arg_y1 C.float
	var wrap_arg_z1 C.float
	var wrap_arg_h C.float
	var wrap_arg_as0 C.float
	var wrap_arg_as1 C.float
	var wrap_arg_col C.uint
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_x0 = (C.float)(x0)
	wrap_arg_y0 = (C.float)(y0)
	wrap_arg_z0 = (C.float)(z0)
	wrap_arg_x1 = (C.float)(x1)
	wrap_arg_y1 = (C.float)(y1)
	wrap_arg_z1 = (C.float)(z1)
	wrap_arg_h = (C.float)(h)
	wrap_arg_as0 = (C.float)(as0)
	wrap_arg_as1 = (C.float)(as1)
	wrap_arg_col = (C.uint)(col)
	C.nav_duAppendArc(wrap_arg_dd, wrap_arg_x0, wrap_arg_y0, wrap_arg_z0, wrap_arg_x1, wrap_arg_y1, wrap_arg_z1, wrap_arg_h, wrap_arg_as0, wrap_arg_as1, wrap_arg_col)
}

/*
void duAppendArrow(duDebugDraw * dd, float const x0, float const y0, float const z0, float const x1, float const y1, float const z1, float const as0, float const as1, unsigned int col)
*/
func DuAppendArrow(dd DuDebugDrawPtr, x0 float32, y0 float32, z0 float32, x1 float32, y1 float32, z1 float32, as0 float32, as1 float32, col uint32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_x0 C.float
	var wrap_arg_y0 C.float
	var wrap_arg_z0 C.float
	var wrap_arg_x1 C.float
	var wrap_arg_y1 C.float
	var wrap_arg_z1 C.float
	var wrap_arg_as0 C.float
	var wrap_arg_as1 C.float
	var wrap_arg_col C.uint
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_x0 = (C.float)(x0)
	wrap_arg_y0 = (C.float)(y0)
	wrap_arg_z0 = (C.float)(z0)
	wrap_arg_x1 = (C.float)(x1)
	wrap_arg_y1 = (C.float)(y1)
	wrap_arg_z1 = (C.float)(z1)
	wrap_arg_as0 = (C.float)(as0)
	wrap_arg_as1 = (C.float)(as1)
	wrap_arg_col = (C.uint)(col)
	C.nav_duAppendArrow(wrap_arg_dd, wrap_arg_x0, wrap_arg_y0, wrap_arg_z0, wrap_arg_x1, wrap_arg_y1, wrap_arg_z1, wrap_arg_as0, wrap_arg_as1, wrap_arg_col)
}

/*
void duAppendBox(duDebugDraw * dd, float minx, float miny, float minz, float maxx, float maxy, float maxz, unsigned int const * fcol)
*/
func DuAppendBox(dd DuDebugDrawPtr, minx float32, miny float32, minz float32, maxx float32, maxy float32, maxz float32, fcol *uint32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_minx C.float
	var wrap_arg_miny C.float
	var wrap_arg_minz C.float
	var wrap_arg_maxx C.float
	var wrap_arg_maxy C.float
	var wrap_arg_maxz C.float
	var wrap_arg_fcol unsafe.Pointer
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_minx = (C.float)(minx)
	wrap_arg_miny = (C.float)(miny)
	wrap_arg_minz = (C.float)(minz)
	wrap_arg_maxx = (C.float)(maxx)
	wrap_arg_maxy = (C.float)(maxy)
	wrap_arg_maxz = (C.float)(maxz)
	wrap_arg_fcol = (unsafe.Pointer)(fcol)
	C.nav_duAppendBox(wrap_arg_dd, wrap_arg_minx, wrap_arg_miny, wrap_arg_minz, wrap_arg_maxx, wrap_arg_maxy, wrap_arg_maxz, wrap_arg_fcol)
}

/*
void duAppendBoxPoints(duDebugDraw * dd, float minx, float miny, float minz, float maxx, float maxy, float maxz, unsigned int col)
*/
func DuAppendBoxPoints(dd DuDebugDrawPtr, minx float32, miny float32, minz float32, maxx float32, maxy float32, maxz float32, col uint32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_minx C.float
	var wrap_arg_miny C.float
	var wrap_arg_minz C.float
	var wrap_arg_maxx C.float
	var wrap_arg_maxy C.float
	var wrap_arg_maxz C.float
	var wrap_arg_col C.uint
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_minx = (C.float)(minx)
	wrap_arg_miny = (C.float)(miny)
	wrap_arg_minz = (C.float)(minz)
	wrap_arg_maxx = (C.float)(maxx)
	wrap_arg_maxy = (C.float)(maxy)
	wrap_arg_maxz = (C.float)(maxz)
	wrap_arg_col = (C.uint)(col)
	C.nav_duAppendBoxPoints(wrap_arg_dd, wrap_arg_minx, wrap_arg_miny, wrap_arg_minz, wrap_arg_maxx, wrap_arg_maxy, wrap_arg_maxz, wrap_arg_col)
}

/*
void duAppendBoxWire(duDebugDraw * dd, float minx, float miny, float minz, float maxx, float maxy, float maxz, unsigned int col)
*/
func DuAppendBoxWire(dd DuDebugDrawPtr, minx float32, miny float32, minz float32, maxx float32, maxy float32, maxz float32, col uint32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_minx C.float
	var wrap_arg_miny C.float
	var wrap_arg_minz C.float
	var wrap_arg_maxx C.float
	var wrap_arg_maxy C.float
	var wrap_arg_maxz C.float
	var wrap_arg_col C.uint
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_minx = (C.float)(minx)
	wrap_arg_miny = (C.float)(miny)
	wrap_arg_minz = (C.float)(minz)
	wrap_arg_maxx = (C.float)(maxx)
	wrap_arg_maxy = (C.float)(maxy)
	wrap_arg_maxz = (C.float)(maxz)
	wrap_arg_col = (C.uint)(col)
	C.nav_duAppendBoxWire(wrap_arg_dd, wrap_arg_minx, wrap_arg_miny, wrap_arg_minz, wrap_arg_maxx, wrap_arg_maxy, wrap_arg_maxz, wrap_arg_col)
}

/*
void duAppendCircle(duDebugDraw * dd, float const x, float const y, float const z, float const r, unsigned int col)
*/
func DuAppendCircle(dd DuDebugDrawPtr, x float32, y float32, z float32, r float32, col uint32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_x C.float
	var wrap_arg_y C.float
	var wrap_arg_z C.float
	var wrap_arg_r C.float
	var wrap_arg_col C.uint
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_x = (C.float)(x)
	wrap_arg_y = (C.float)(y)
	wrap_arg_z = (C.float)(z)
	wrap_arg_r = (C.float)(r)
	wrap_arg_col = (C.uint)(col)
	C.nav_duAppendCircle(wrap_arg_dd, wrap_arg_x, wrap_arg_y, wrap_arg_z, wrap_arg_r, wrap_arg_col)
}

/*
void duAppendCross(duDebugDraw * dd, float const x, float const y, float const z, float const size, unsigned int col)
*/
func DuAppendCross(dd DuDebugDrawPtr, x float32, y float32, z float32, size float32, col uint32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_x C.float
	var wrap_arg_y C.float
	var wrap_arg_z C.float
	var wrap_arg_size C.float
	var wrap_arg_col C.uint
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_x = (C.float)(x)
	wrap_arg_y = (C.float)(y)
	wrap_arg_z = (C.float)(z)
	wrap_arg_size = (C.float)(size)
	wrap_arg_col = (C.uint)(col)
	C.nav_duAppendCross(wrap_arg_dd, wrap_arg_x, wrap_arg_y, wrap_arg_z, wrap_arg_size, wrap_arg_col)
}

/*
void duAppendCylinder(duDebugDraw * dd, float minx, float miny, float minz, float maxx, float maxy, float maxz, unsigned int col)
*/
func DuAppendCylinder(dd DuDebugDrawPtr, minx float32, miny float32, minz float32, maxx float32, maxy float32, maxz float32, col uint32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_minx C.float
	var wrap_arg_miny C.float
	var wrap_arg_minz C.float
	var wrap_arg_maxx C.float
	var wrap_arg_maxy C.float
	var wrap_arg_maxz C.float
	var wrap_arg_col C.uint
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_minx = (C.float)(minx)
	wrap_arg_miny = (C.float)(miny)
	wrap_arg_minz = (C.float)(minz)
	wrap_arg_maxx = (C.float)(maxx)
	wrap_arg_maxy = (C.float)(maxy)
	wrap_arg_maxz = (C.float)(maxz)
	wrap_arg_col = (C.uint)(col)
	C.nav_duAppendCylinder(wrap_arg_dd, wrap_arg_minx, wrap_arg_miny, wrap_arg_minz, wrap_arg_maxx, wrap_arg_maxy, wrap_arg_maxz, wrap_arg_col)
}

/*
Versions without beginend, can be used to draw multiple primitives.

void duAppendCylinderWire(duDebugDraw * dd, float minx, float miny, float minz, float maxx, float maxy, float maxz, unsigned int col)
*/
func DuAppendCylinderWire(dd DuDebugDrawPtr, minx float32, miny float32, minz float32, maxx float32, maxy float32, maxz float32, col uint32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_minx C.float
	var wrap_arg_miny C.float
	var wrap_arg_minz C.float
	var wrap_arg_maxx C.float
	var wrap_arg_maxy C.float
	var wrap_arg_maxz C.float
	var wrap_arg_col C.uint
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_minx = (C.float)(minx)
	wrap_arg_miny = (C.float)(miny)
	wrap_arg_minz = (C.float)(minz)
	wrap_arg_maxx = (C.float)(maxx)
	wrap_arg_maxy = (C.float)(maxy)
	wrap_arg_maxz = (C.float)(maxz)
	wrap_arg_col = (C.uint)(col)
	C.nav_duAppendCylinderWire(wrap_arg_dd, wrap_arg_minx, wrap_arg_miny, wrap_arg_minz, wrap_arg_maxx, wrap_arg_maxy, wrap_arg_maxz, wrap_arg_col)
}

/*
void duCalcBoxColors(unsigned int * colors, unsigned int colTop, unsigned int colSide)
*/
func DuCalcBoxColors(colors *uint32, colTop uint32, colSide uint32) {
	var wrap_arg_colors unsafe.Pointer
	var wrap_arg_colTop C.uint
	var wrap_arg_colSide C.uint
	wrap_arg_colors = (unsafe.Pointer)(colors)
	wrap_arg_colTop = (C.uint)(colTop)
	wrap_arg_colSide = (C.uint)(colSide)
	C.nav_duCalcBoxColors(wrap_arg_colors, wrap_arg_colTop, wrap_arg_colSide)
}

/*
unsigned int duDarkenCol(unsigned int col)
*/
func DuDarkenCol(col uint32) uint32 {
	var wrap_arg_col C.uint
	wrap_arg_col = (C.uint)(col)
	wrap_out := C.nav_duDarkenCol(wrap_arg_col)
	go_out := uint32(wrap_out)
	return go_out
}

/*
void duDebugDrawArc(duDebugDraw * dd, float const x0, float const y0, float const z0, float const x1, float const y1, float const z1, float const h, float const as0, float const as1, unsigned int col, float const lineWidth)
*/
func DuDebugDrawArc(dd DuDebugDrawPtr, x0 float32, y0 float32, z0 float32, x1 float32, y1 float32, z1 float32, h float32, as0 float32, as1 float32, col uint32, lineWidth float32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_x0 C.float
	var wrap_arg_y0 C.float
	var wrap_arg_z0 C.float
	var wrap_arg_x1 C.float
	var wrap_arg_y1 C.float
	var wrap_arg_z1 C.float
	var wrap_arg_h C.float
	var wrap_arg_as0 C.float
	var wrap_arg_as1 C.float
	var wrap_arg_col C.uint
	var wrap_arg_lineWidth C.float
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_x0 = (C.float)(x0)
	wrap_arg_y0 = (C.float)(y0)
	wrap_arg_z0 = (C.float)(z0)
	wrap_arg_x1 = (C.float)(x1)
	wrap_arg_y1 = (C.float)(y1)
	wrap_arg_z1 = (C.float)(z1)
	wrap_arg_h = (C.float)(h)
	wrap_arg_as0 = (C.float)(as0)
	wrap_arg_as1 = (C.float)(as1)
	wrap_arg_col = (C.uint)(col)
	wrap_arg_lineWidth = (C.float)(lineWidth)
	C.nav_duDebugDrawArc(wrap_arg_dd, wrap_arg_x0, wrap_arg_y0, wrap_arg_z0, wrap_arg_x1, wrap_arg_y1, wrap_arg_z1, wrap_arg_h, wrap_arg_as0, wrap_arg_as1, wrap_arg_col, wrap_arg_lineWidth)
}

/*
void duDebugDrawArrow(duDebugDraw * dd, float const x0, float const y0, float const z0, float const x1, float const y1, float const z1, float const as0, float const as1, unsigned int col, float const lineWidth)
*/
func DuDebugDrawArrow(dd DuDebugDrawPtr, x0 float32, y0 float32, z0 float32, x1 float32, y1 float32, z1 float32, as0 float32, as1 float32, col uint32, lineWidth float32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_x0 C.float
	var wrap_arg_y0 C.float
	var wrap_arg_z0 C.float
	var wrap_arg_x1 C.float
	var wrap_arg_y1 C.float
	var wrap_arg_z1 C.float
	var wrap_arg_as0 C.float
	var wrap_arg_as1 C.float
	var wrap_arg_col C.uint
	var wrap_arg_lineWidth C.float
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_x0 = (C.float)(x0)
	wrap_arg_y0 = (C.float)(y0)
	wrap_arg_z0 = (C.float)(z0)
	wrap_arg_x1 = (C.float)(x1)
	wrap_arg_y1 = (C.float)(y1)
	wrap_arg_z1 = (C.float)(z1)
	wrap_arg_as0 = (C.float)(as0)
	wrap_arg_as1 = (C.float)(as1)
	wrap_arg_col = (C.uint)(col)
	wrap_arg_lineWidth = (C.float)(lineWidth)
	C.nav_duDebugDrawArrow(wrap_arg_dd, wrap_arg_x0, wrap_arg_y0, wrap_arg_z0, wrap_arg_x1, wrap_arg_y1, wrap_arg_z1, wrap_arg_as0, wrap_arg_as1, wrap_arg_col, wrap_arg_lineWidth)
}

/*
void duDebugDrawBox(duDebugDraw * dd, float minx, float miny, float minz, float maxx, float maxy, float maxz, unsigned int const * fcol)
*/
func DuDebugDrawBox(dd DuDebugDrawPtr, minx float32, miny float32, minz float32, maxx float32, maxy float32, maxz float32, fcol *uint32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_minx C.float
	var wrap_arg_miny C.float
	var wrap_arg_minz C.float
	var wrap_arg_maxx C.float
	var wrap_arg_maxy C.float
	var wrap_arg_maxz C.float
	var wrap_arg_fcol unsafe.Pointer
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_minx = (C.float)(minx)
	wrap_arg_miny = (C.float)(miny)
	wrap_arg_minz = (C.float)(minz)
	wrap_arg_maxx = (C.float)(maxx)
	wrap_arg_maxy = (C.float)(maxy)
	wrap_arg_maxz = (C.float)(maxz)
	wrap_arg_fcol = (unsafe.Pointer)(fcol)
	C.nav_duDebugDrawBox(wrap_arg_dd, wrap_arg_minx, wrap_arg_miny, wrap_arg_minz, wrap_arg_maxx, wrap_arg_maxy, wrap_arg_maxz, wrap_arg_fcol)
}

/*
void duDebugDrawBoxWire(duDebugDraw * dd, float minx, float miny, float minz, float maxx, float maxy, float maxz, unsigned int col, float const lineWidth)
*/
func DuDebugDrawBoxWire(dd DuDebugDrawPtr, minx float32, miny float32, minz float32, maxx float32, maxy float32, maxz float32, col uint32, lineWidth float32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_minx C.float
	var wrap_arg_miny C.float
	var wrap_arg_minz C.float
	var wrap_arg_maxx C.float
	var wrap_arg_maxy C.float
	var wrap_arg_maxz C.float
	var wrap_arg_col C.uint
	var wrap_arg_lineWidth C.float
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_minx = (C.float)(minx)
	wrap_arg_miny = (C.float)(miny)
	wrap_arg_minz = (C.float)(minz)
	wrap_arg_maxx = (C.float)(maxx)
	wrap_arg_maxy = (C.float)(maxy)
	wrap_arg_maxz = (C.float)(maxz)
	wrap_arg_col = (C.uint)(col)
	wrap_arg_lineWidth = (C.float)(lineWidth)
	C.nav_duDebugDrawBoxWire(wrap_arg_dd, wrap_arg_minx, wrap_arg_miny, wrap_arg_minz, wrap_arg_maxx, wrap_arg_maxy, wrap_arg_maxz, wrap_arg_col, wrap_arg_lineWidth)
}

/*
void duDebugDrawCircle(duDebugDraw * dd, float const x, float const y, float const z, float const r, unsigned int col, float const lineWidth)
*/
func DuDebugDrawCircle(dd DuDebugDrawPtr, x float32, y float32, z float32, r float32, col uint32, lineWidth float32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_x C.float
	var wrap_arg_y C.float
	var wrap_arg_z C.float
	var wrap_arg_r C.float
	var wrap_arg_col C.uint
	var wrap_arg_lineWidth C.float
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_x = (C.float)(x)
	wrap_arg_y = (C.float)(y)
	wrap_arg_z = (C.float)(z)
	wrap_arg_r = (C.float)(r)
	wrap_arg_col = (C.uint)(col)
	wrap_arg_lineWidth = (C.float)(lineWidth)
	C.nav_duDebugDrawCircle(wrap_arg_dd, wrap_arg_x, wrap_arg_y, wrap_arg_z, wrap_arg_r, wrap_arg_col, wrap_arg_lineWidth)
}

/*
void duDebugDrawCross(duDebugDraw * dd, float const x, float const y, float const z, float const size, unsigned int col, float const lineWidth)
*/
func DuDebugDrawCross(dd DuDebugDrawPtr, x float32, y float32, z float32, size float32, col uint32, lineWidth float32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_x C.float
	var wrap_arg_y C.float
	var wrap_arg_z C.float
	var wrap_arg_size C.float
	var wrap_arg_col C.uint
	var wrap_arg_lineWidth C.float
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_x = (C.float)(x)
	wrap_arg_y = (C.float)(y)
	wrap_arg_z = (C.float)(z)
	wrap_arg_size = (C.float)(size)
	wrap_arg_col = (C.uint)(col)
	wrap_arg_lineWidth = (C.float)(lineWidth)
	C.nav_duDebugDrawCross(wrap_arg_dd, wrap_arg_x, wrap_arg_y, wrap_arg_z, wrap_arg_size, wrap_arg_col, wrap_arg_lineWidth)
}

/*
void duDebugDrawCylinder(duDebugDraw * dd, float minx, float miny, float minz, float maxx, float maxy, float maxz, unsigned int col)
*/
func DuDebugDrawCylinder(dd DuDebugDrawPtr, minx float32, miny float32, minz float32, maxx float32, maxy float32, maxz float32, col uint32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_minx C.float
	var wrap_arg_miny C.float
	var wrap_arg_minz C.float
	var wrap_arg_maxx C.float
	var wrap_arg_maxy C.float
	var wrap_arg_maxz C.float
	var wrap_arg_col C.uint
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_minx = (C.float)(minx)
	wrap_arg_miny = (C.float)(miny)
	wrap_arg_minz = (C.float)(minz)
	wrap_arg_maxx = (C.float)(maxx)
	wrap_arg_maxy = (C.float)(maxy)
	wrap_arg_maxz = (C.float)(maxz)
	wrap_arg_col = (C.uint)(col)
	C.nav_duDebugDrawCylinder(wrap_arg_dd, wrap_arg_minx, wrap_arg_miny, wrap_arg_minz, wrap_arg_maxx, wrap_arg_maxy, wrap_arg_maxz, wrap_arg_col)
}

/*
void duDebugDrawCylinderWire(duDebugDraw * dd, float minx, float miny, float minz, float maxx, float maxy, float maxz, unsigned int col, float const lineWidth)
*/
func DuDebugDrawCylinderWire(dd DuDebugDrawPtr, minx float32, miny float32, minz float32, maxx float32, maxy float32, maxz float32, col uint32, lineWidth float32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_minx C.float
	var wrap_arg_miny C.float
	var wrap_arg_minz C.float
	var wrap_arg_maxx C.float
	var wrap_arg_maxy C.float
	var wrap_arg_maxz C.float
	var wrap_arg_col C.uint
	var wrap_arg_lineWidth C.float
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_minx = (C.float)(minx)
	wrap_arg_miny = (C.float)(miny)
	wrap_arg_minz = (C.float)(minz)
	wrap_arg_maxx = (C.float)(maxx)
	wrap_arg_maxy = (C.float)(maxy)
	wrap_arg_maxz = (C.float)(maxz)
	wrap_arg_col = (C.uint)(col)
	wrap_arg_lineWidth = (C.float)(lineWidth)
	C.nav_duDebugDrawCylinderWire(wrap_arg_dd, wrap_arg_minx, wrap_arg_miny, wrap_arg_minz, wrap_arg_maxx, wrap_arg_maxy, wrap_arg_maxz, wrap_arg_col, wrap_arg_lineWidth)
}

/*
void duDebugDrawGridXZ(duDebugDraw * dd, float const ox, float const oy, float const oz, int const w, int const h, float const size, unsigned int const col, float const lineWidth)
*/
func DuDebugDrawGridXZ(dd DuDebugDrawPtr, ox float32, oy float32, oz float32, w int32, h int32, size float32, col uint32, lineWidth float32) {
	var wrap_arg_dd unsafe.Pointer
	var wrap_arg_ox C.float
	var wrap_arg_oy C.float
	var wrap_arg_oz C.float
	var wrap_arg_w C.int
	var wrap_arg_h C.int
	var wrap_arg_size C.float
	var wrap_arg_col C.uint
	var wrap_arg_lineWidth C.float
	wrap_arg_dd = (unsafe.Pointer)(dd)
	wrap_arg_ox = (C.float)(ox)
	wrap_arg_oy = (C.float)(oy)
	wrap_arg_oz = (C.float)(oz)
	wrap_arg_w = (C.int)(w)
	wrap_arg_h = (C.int)(h)
	wrap_arg_size = (C.float)(size)
	wrap_arg_col = (C.uint)(col)
	wrap_arg_lineWidth = (C.float)(lineWidth)
	C.nav_duDebugDrawGridXZ(wrap_arg_dd, wrap_arg_ox, wrap_arg_oy, wrap_arg_oz, wrap_arg_w, wrap_arg_h, wrap_arg_size, wrap_arg_col, wrap_arg_lineWidth)
}

/*
unsigned int duIntToCol(int i, int a)
*/
func DuIntToCol(i int32, a int32) uint32 {
	var wrap_arg_i C.int
	var wrap_arg_a C.int
	wrap_arg_i = (C.int)(i)
	wrap_arg_a = (C.int)(a)
	wrap_out := C.nav_duIntToCol(wrap_arg_i, wrap_arg_a)
	go_out := uint32(wrap_out)
	return go_out
}

/*
void duIntToCol(int i, float * col)
*/
func DuIntToCol11(i int32, col *float32) {
	var wrap_arg_i C.int
	var wrap_arg_col unsafe.Pointer
	wrap_arg_i = (C.int)(i)
	wrap_arg_col = (unsafe.Pointer)(col)
	C.nav_duIntToCol11(wrap_arg_i, wrap_arg_col)
}

/*
unsigned int duLerpCol(unsigned int ca, unsigned int cb, unsigned int u)
*/
func DuLerpCol(ca uint32, cb uint32, u uint32) uint32 {
	var wrap_arg_ca C.uint
	var wrap_arg_cb C.uint
	var wrap_arg_u C.uint
	wrap_arg_ca = (C.uint)(ca)
	wrap_arg_cb = (C.uint)(cb)
	wrap_arg_u = (C.uint)(u)
	wrap_out := C.nav_duLerpCol(wrap_arg_ca, wrap_arg_cb, wrap_arg_u)
	go_out := uint32(wrap_out)
	return go_out
}

/*
unsigned int duMultCol(unsigned int const col, unsigned int const d)
*/
func DuMultCol(col uint32, d uint32) uint32 {
	var wrap_arg_col C.uint
	var wrap_arg_d C.uint
	wrap_arg_col = (C.uint)(col)
	wrap_arg_d = (C.uint)(d)
	wrap_out := C.nav_duMultCol(wrap_arg_col, wrap_arg_d)
	go_out := uint32(wrap_out)
	return go_out
}

/*
unsigned int duRGBA(int r, int g, int b, int a)
*/
func DuRGBA(r int32, g int32, b int32, a int32) uint32 {
	var wrap_arg_r C.int
	var wrap_arg_g C.int
	var wrap_arg_b C.int
	var wrap_arg_a C.int
	wrap_arg_r = (C.int)(r)
	wrap_arg_g = (C.int)(g)
	wrap_arg_b = (C.int)(b)
	wrap_arg_a = (C.int)(a)
	wrap_out := C.nav_duRGBA(wrap_arg_r, wrap_arg_g, wrap_arg_b, wrap_arg_a)
	go_out := uint32(wrap_out)
	return go_out
}

/*
unsigned int duRGBAf(float fr, float fg, float fb, float fa)
*/
func DuRGBAf(fr float32, fg float32, fb float32, fa float32) uint32 {
	var wrap_arg_fr C.float
	var wrap_arg_fg C.float
	var wrap_arg_fb C.float
	var wrap_arg_fa C.float
	wrap_arg_fr = (C.float)(fr)
	wrap_arg_fg = (C.float)(fg)
	wrap_arg_fb = (C.float)(fb)
	wrap_arg_fa = (C.float)(fa)
	wrap_out := C.nav_duRGBAf(wrap_arg_fr, wrap_arg_fg, wrap_arg_fb, wrap_arg_fa)
	go_out := uint32(wrap_out)
	return go_out
}

/*
unsigned int duTransCol(unsigned int c, unsigned int a)
*/
func DuTransCol(c uint32, a uint32) uint32 {
	var wrap_arg_c C.uint
	var wrap_arg_a C.uint
	wrap_arg_c = (C.uint)(c)
	wrap_arg_a = (C.uint)(a)
	wrap_out := C.nav_duTransCol(wrap_arg_c, wrap_arg_a)
	go_out := uint32(wrap_out)
	return go_out
}

type EnumDuDebugDrawPrimitives uint32

const (
	EnumDuDebugDrawPrimitives_DU_DRAW_POINTS EnumDuDebugDrawPrimitives = 0
	EnumDuDebugDrawPrimitives_DU_DRAW_LINES  EnumDuDebugDrawPrimitives = 1
	EnumDuDebugDrawPrimitives_DU_DRAW_TRIS   EnumDuDebugDrawPrimitives = 2
	EnumDuDebugDrawPrimitives_DU_DRAW_QUADS  EnumDuDebugDrawPrimitives = 3
)
